System and method for enforcing security policies in a virtual environment

ABSTRACT

A method in one example implementation includes intercepting a request associated with an execution of an object (e.g., a kernel module or a binary) in a computer configured to operate in a virtual machine environment. The request is associated with a privileged domain of the computer that operates logically below one or more operating systems. The method also includes verifying an authorization of the object by computing a checksum for the object and comparing the checksum to a plurality of stored checksums in a memory element. The execution of the object is denied if it is not authorized. In other embodiments, the method can include evaluating a plurality of entries within the memory element of the computer, wherein the entries include authorized binaries and kernel modules. In other embodiments, the method can include intercepting an attempt from a remote computer to execute code from a previously authorized binary.

RELATED APPLICATIONS

This Application is a continuation of U.S. application Ser. No. 13/723,445, filed Dec. 21, 2012, which is a continuation application (and claims the benefit of priority under 35 U.S.C. §120) of U.S. application Ser. No. 12/545,609, filed Aug. 21, 2009 The disclosure of the prior applications are considered part of (and are incorporated by reference in) the disclosure of this application.

TECHNICAL FIELD

This disclosure relates in general to the field of security and, more particularly, to enforcing security policies in a virtual environment.

BACKGROUND

The field of network security has become increasingly important in today's society. In particular, the ability to effectively protect computers and systems presents a significant obstacle for component manufacturers, system designers, and network operators. This obstacle is made even more difficult due to the plethora of new security threats, which seem to evolve daily. Virtualization is a software technology allowing an operating system to run unmodified on an isolated virtual environment (typically referred to as a virtual machine), where a platform's physical characteristics and behaviors are reproduced. More specifically, a virtual machine can represent an isolated, virtual environment (lying on top of a host operating system (OS)) and equipped with virtual hardware (processor, memory, disks, network interfaces, etc.). Commonly, the virtual machine is managed by a virtualization product. A virtual machine monitor (VMM) is the virtualization software layer that manages hardware requests from a guest OS (e.g., simulating answers from real hardware). A hypervisor is computer software/hardware platform virtualization software that allows multiple operating systems to run on a host computer concurrently. Both Xen and Hypervisor represent forms of VMMs and these VMMs can be exploited to better protect computers and systems from emerging security threats.

BRIEF DESCRIPTION OF THE DRAWINGS

To provide a more complete understanding of the present disclosure and features and advantages thereof, reference is made to the following description, taken in conjunction with the accompanying figures, wherein like reference numerals represent like parts, in which:

FIG. 1 is a simplified block diagram of a system for enforcing security policies in a privileged domain of a virtual environment in accordance with one embodiment;

FIG. 2 is a simplified view of processor privilege level ring usage in accordance with one embodiment;

FIG. 3 is a simplified block diagram of a system for enforcing security policies in a privileged domain of a virtual environment in accordance with another embodiment;

FIG. 4 is a simplified block diagram providing an overview of components and processes in Domain 0 and, further, their interactions with a virtual machine monitor in accordance with another embodiment; and

FIG. 5 is a simplified flowchart illustrating a series of example steps associated with the system in accordance with one embodiment.

DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS

Overview

A method in one example implementation includes intercepting a request associated with an execution of an object (e.g., a kernel module or a binary) in a computer configured to operate in a virtual machine environment. The request for the execution is associated with a privileged domain of the computer that operates logically below one or more operating systems. The method also includes verifying an authorization of the object by computing a checksum for the object and comparing the checksum to a plurality of stored checksums in a memory element. The method further includes denying the execution of the object if it is not authorized. In other embodiments, the method can include evaluating a plurality of entries within the memory element of the computer, wherein the entries include authorized binaries and kernel modules. In other embodiments, the method can include intercepting an attempt from a remote computer to execute code from a previously authorized binary, and evaluating an origination address of a hypercall associated with the code before executing the code.

EXAMPLE EMBODIMENTS

FIG. 1 is a simplified block diagram of a system 10 for enforcing security policies in a privileged domain of a virtual environment. Such an architecture can provide a secure environment for the execution of operations in the privileged domain, as well as in other guest operating systems. In one example implementation, FIG. 1 includes a user space 12, a kernel space 14, a virtual machine monitor 16, and a kernel module 20, which includes an inventory 24. Virtual machine monitor 16 may include a memory element 18 and a processor 22 in one example implementation. In addition, FIG. 1 may include a system call table 28, a management interface 40, and a control module 34, which includes an inventory 36. A system call 42 is also provided, and this element interfaces with a loading and routines element 30, which interacts with inventory 24. Not shown in FIG. 1 is additional hardware that may be suitably coupled to virtual machine monitor (VMM) 16 (e.g., provided below its logical representation) in the form of memory management units (MMU), symmetric multiprocessing (SMP) elements, physical memory, Ethernet, small computer system interface (SCSI)/integrated drive electronics (IDE) elements, etc.

For purposes of illustrating the techniques of system 10, it is important to understand the activities occurring within a given virtual system. The following foundational information may be viewed as a basis from which the present disclosure may be properly explained. Such information is offered earnestly for purposes of explanation only and, accordingly, should not be construed in any way to limit the broad scope of the present disclosure and its potential applications. Virtual machine monitors (e.g., Xen and HyperV) are hypervisors that currently fail to offer an interface to the end user to properly manage virtual machines and guest operating system (OS) instances. As used herein in this Specification, the term ‘virtual machine element’ is meant to include any such hypervisors, or other devices that operate in a virtual environment. It should also be noted that these hypervisor's fail to offer suitable device drivers. Both of the above functionalities are commonly provided by a special privileged domain/partition. Generally, these privileged domains can host device drivers and, further, provide an interface for managing virtual machine monitor 16 and guest OS instances.

Any grant of special privileges to a particular domain poses security risks for other guest OS instances. A compromised privileged domain can readily degrade the security of all guest OS instances running on a computer. In essence, hypervisors and privileged domains can unknowingly engender new attack vectors that are not adequately protected by current security solutions. System 10 offers a viable architecture to thwart these new categories of attacks, as well as other security risks presented to a given computer.

Consider a first example in which some type of malware is attempting to run a kernel module, which is not authorized. A hypercall is a function that is generally used by a kernel module to interact with a virtual machine. For example, a hypercall could be used by the kernel module to access specific areas of a given machine. The hypercall can shut down the virtual machine and, in a worst-case scenario, control all the other virtual machines to which it can communicate. Thus, the ability of certain code (e.g., in the form of a hypercall) to enter a certain space and to improperly manipulate the system is problematic.

The primary attack vectors that can compromise a privileged domain include: 1) execution of an unauthorized user binary (malware/virus)/kernel module; 2) execution of a vulnerable authorized binary; and 3) execution of unauthorized hypercalls. System 10 can be used to enforce security policies in the privileged domain. The present disclosure is directed towards securing privileged domains/partitions. In certain embodiments, the current disclosure works by inserting a security layer in the Domain 0 kernel, which protects: 1) against execution of unauthorized user space binaries/kernel module; and 2) against execution of vulnerable authorized binary.

The system can be configured to take a snapshot of all the valid binaries and kernel modules and store the information in a user space database/inventory. The kernel security layer (in Domain 0) can intercept a kernel module and binary load routine and, subsequently, fetch inventory data from the user space inventory. When a particular request for execution of a kernel module or of a binary occurs, an intercept function is invoked that checks for an authorization of the loaded module or binary. The intercepting function allows execution of only authorized binaries/modules. Note that in computing, an executable (file) causes a computer to perform indicated tasks according to encoded instructions, as opposed to a file that only contains data. Files that contain instructions for an interpreter or virtual machine may be considered ‘executables’ or ‘binaries’ in contrast to program source code. The more generic term ‘object’ (as used herein in this Specification) is meant to include any such executables, binaries, kernel modules, improper hypercalls, etc., which are sought to be invoked, initiated, or otherwise executed.

The current disclosure also protects against execution of unauthorized hypercalls if a currently running binary is exploited. This is important because an attacker could use hypercalls to take over the entire virtual infrastructure. In such an implementation, the security layer checks for an origination address of hypercalls. The security layer can randomize hypercalls such that only authorized binaries can invoke the appropriate hypercalls.

Note that no security solution exists that effectively protects the privileged domain (Domain 0) as a special entity. Common solutions to the issues detailed herein include security software that would normally run on a commodity operating system. Security of privileged domains is an area of active research; however, there is no solution available that proactively protects the critical domains. System 10, by contrast, can treat the privileged domain as special and protect it against the new attack vectors involved. This is in contrast to more generalized solutions, which do not specifically target protection for Domain 0.

Turning to the infrastructure of FIG. 1, virtual machine monitor 16 can run multiple instances of guest OSs. Logically, this element can be thought of as the hypervisor in certain implementations. Virtual machine monitor 16 can be part of a server, a firewall, an antivirus solution, or more generically, a computer. Kernel space 14 of the virtual machine is the area where a security layer can be inserted. In this particular case, kernel space 14 is associated with Domain 0. An operating system usually segregates virtual memory into kernel space and user space. Kernel space is commonly reserved for running a kernel, the kernel extensions, and certain device drivers. In contrast, user space is the memory area where user mode applications work and this memory can be swapped out (if necessary).

Each user space process normally runs in its own virtual memory space and, unless explicitly requested, does not access the memory of other processes. This is the basis for memory protection in mainstream operating systems, and a building block for privilege separation. In another approach, a single address space for all software is used, where the programming language's virtual machine ensures that arbitrary memory cannot be accessed. Applications simply cannot acquire references to the objects that they are not allowed to access.

Kernel module 20 represents the security layer in the Domain 0 kernel, which provides protection to the domain against unauthorized (and vulnerable authorized) binaries and kernel modules. In some attack scenarios, this can be the source of hypercalls. A hypercall is a software trap from a domain (e.g., Domain 0) to the hypervisor, just as a syscall is a software trap from an application to the kernel. Domains can use hypercalls to request privileged operations like updating page tables. Like a syscall, the hypercall is synchronous, where the return path from the hypervisor to the domain can employ event channels.

In one example implementation, virtual machine monitor 16 is a Xen element, which is a hypervisor that runs on bare hardware and which provides the capability of running multiple instances of OSs simultaneously on the same hardware. A typical Xen setup may involve Xen running beneath multiple OSs, where applications are on top of the OSs, which are associated with a group of virtual machines. The entire configuration may be provided in a server (or some other network appliance). One of the virtual machines can be running an OS associated with Domain 0. This VM (Dom 0) provides the user with the interface to manage this complete setup, and also hosts the device drivers. This management includes the hypervisor configuration, VM configuration, creation, deletion, shutdown, startup, etc. of VMs. This kind of setup can be popular in data centers where servers run Xen, which in turn hosts multiple instances of guest OSs (VMs). Each such server can have one Domain 0. The features discussed herein can effectively secure this Domain 0, as detailed below.

In most virtualization scenarios, one of the virtual elements is referred to as Domain 0, and it has administrative authority to control other virtual machines. This domain represents a privileged area and, therefore, it should be protected. In one example implementation, virtual machine monitor 16 is a Xen element configured to carry out some of the protection operations as outlined herein. Note that this Xen implementation is only representing one possible example to which the present disclosure can apply. Any number of additional hypervisors or virtual elements could similarly benefit from the broad teachings discussed herein.

In one example, a hypervisor can offer tools and applications necessary to support a complete virtualization environment. The hypervisor is the basic abstraction layer of software that sits directly on the hardware below operating systems. It is responsible for central processing unit (CPU) scheduling and memory partitioning of the various virtual machines running on a hardware device. The hypervisor not only abstracts the hardware for the virtual machines, but also controls the execution of virtual machines as they share the common processing environment.

Inventory 24 represents a memory element (e.g., a database) that may be provided in a security layer that keeps information about authorized binaries and kernel modules. System call table 28 is configured to intercept loading of modules and binaries in a given computer. Loading routines module 30 provides functionality for hooked routines, which can perform a check on each kernel module and binary. Control module 34 offers control for the security layer in user space 12. Control module 34 may include inventory 36, which represents user space inventory that gets pushed to the kernel security layer. Both instances of inventory 24 and 36 may be updated, and/or suitably modified based on systematic configurations, or events that trigger a change to either of these inventories. Management interface 40 can be configured to control the behavior of a security agent, which is relegated the task of protecting a computer.

In operation of a simple example, a loadable kernel module (LKM) represents a system commonly used by Linux (as well as some other modern operating systems) to allow the linking of object code into a running kernel without interrupting system traffic. At a fundamental level, an object is compiled to a re-locatable object (.o) file, loaded using ‘insmod’ under Linux, and removed using ‘rmmod’. Linux also supports demand loading of modules using ‘kerneld’ (now kmod).

Once ‘insmod’ is called, the module is linked into the running system kernel and the function init_module ( ) is called. All modules should contain this function, as well as a cleanup_module ( ), which is called at unloading. The purpose of the init_module ( ) is to register the functions contained within the module to handle system events, such as to operate as device drivers or interrupt handlers. The actions performed by insmod are similar to that of ‘Id’, for example, in regards to linkage.

In this example, when a request to run a binary or kernel module is intercepted, it is checked to see whether it is authorized. For example, a security agent (e.g., a piece of software running in Domain 0) can be configured to compute checksums in order to validate whether a given element (i.e., a binary or a kernel module) is authorized for the particular system. This may include look up operations in which stored inventories are compared against a new request for binaries or kernel modules in order to discern whether to allow these elements to be executed. Thus, the comparison is being made against internally stored items.

The interaction in the architecture of FIG. 1 occurs between system call 42 and loading routines module 30, where a checksum is computed and looked up in an associated inventory. If the checksum is found, then the request is authorized (e.g., ‘return original init [initiate] module’), but if the request is not authorized, then an ‘EPERM’ command is sent, which indicates that the operation is not permitted. More detailed operations associated with these activities are provided below with reference to specific example flows.

Turning to FIG. 2, FIG. 2 is a simplified schematic diagram illustrating a hierarchy 50 of domains within a given computer. More specifically, FIG. 2 depicts a processor privilege level ring usage (x86) in accordance with one embodiment. This ring usage can be associated with a para virtualized system, where a Xen VMM runs in Ring 0, Domain 0, and other guest OS kernels run in Ring 1 and Domain 0 (and additional guest OS user space applications can run in Ring3). Note that the Rings correspond to specific domains in this illustration such that the most privileged domain is represented By Ring 0 (i.e., Domain 0). This is associated with virtual machine monitor 16, where a guest operating system corresponds to Ring 1, and applications correspond to Ring 2 and/or Ring 3. It should also be noted that hypercalls could easily jump to virtual machine monitor 16, or Ring 0, which is problematic for the reasons discussed herein.

Domain 0, a modified Linux kernel, is a unique virtual machine running on the hypervisor that has special rights to access physical I/O resources, as well as interact with the other virtual machines (Domain U: PV and HVM Guests) running on the system. Domain 0 is the first domain launched when the system is booted, and it can be used to create and configure all other regular guest domains. Domain 0 is also sometimes called Dom0 and, similarly, a regular guest domain is called a DomU or unprivileged domain. Virtualization environments can require Domain 0 to be running before other virtual machines can be started. Two drivers are generally included in Domain 0 to support network and local disk requests from Domain U PV and HVM Guests: the Network Backend Driver and the Block Backend Driver. The Network Backend Driver communicates directly with the local networking hardware to process all virtual machines requests coming from the Domain U guests. The Block Backend Driver communicates with the local storage disk to read and write data from the drive based upon Domain U requests.

Thus, a given hypervisor is not alone in its task of administering the guest domains on the system. A special privileged domain (Domain 0) serves as an administrative interface to Xen. Domain 0 has direct physical access to hardware, and it exports the simplified generic class devices to each DomU. Rather than emulating the actual physical devices exactly, the hypervisor exposes idealized devices. For example, the guest domain views the network card as a generic network class device or the disk as a generic block class device. Domain 0 runs a device driver specific to each actual physical device and then communicates with other guest domains through an asynchronous shared memory transport.

Domain 0 can also delegate responsibility for a particular device to another domain. A driver domain is a DomU that runs a minimal kernel and the backend for a particular device. This has the advantage of moving the complexity and risk of device management out of the Domain 0. Moving device management to driver domains can make the system more stable because hardware drivers are notoriously the most error-prone code in an operating system. A driver domain could be stopped and restarted to recover from an error, while stopping and restarting Domain 0 can disrupt the entire system.

As a general proposition, a smaller and simpler Domain 0 is better for the security and stability of the system. Moving device management into driver domains is just one example of this. Although Domain 0 typically runs a general-purpose operating system, it is wise to use Domain 0 strictly for the administration of virtual machines on the system. All other applications can be run in a guest domain. Overall, a bare-bones Domain 0 is less vulnerable to attack or accidental software fault.

FIG. 3 is a simplified block diagram of an LKM authentication implementation 60 in accordance with one example of the present disclosure. FIG. 3 includes many of the same components as FIG. 1, with the addition of a filename based inventory 52 and a checksum based inventory (LKM) 54. In addition, a logical representation of an inventory entry 56 is depicted. Inventory entry 56 includes various fields including a filename, a checksum, an LKM, etc.

As discussed above, there are several Domain 0 security issues in such a scenario. These include unauthorized binary execution, or the propagation of malware capable of modifying the VM state (e.g., via ioctl). Another security risk is presented by the remote code injection in authorized binary to modify the VM state (e.g., via ioctl). Note that in computing, an ioctl is typically the part of the user-to-kernel interface of an operating system. The acronym is short for “Input/output control,” where ioctls are commonly employed to allow user space code to communicate with hardware devices or kernel components. The other threat in such a scenario involves an unauthorized Linux kernel module (e.g., a hypercall). The architecture of FIG. 3 may operate to protect Domain 0 in the following ways. First, the architecture can prevent any execution of unauthorized binaries. Second, the architecture can prevent an ioctl from a writable memory area (e.g., in the context of a buffer overflow attack). In addition, the architecture can protect the system by allowing only authorized LKMs to load.

FIG. 4 is a simplified block diagram of an exploit prevention implementation 62 in accordance with one example of the present disclosure. FIG. 4 depicts an overview of components and processes in Domain 0 and, further, their interactions with a virtual machine monitor (e.g., a Xen VMM). The architecture of FIG. 4 includes a user space 64, a kernel space 66, and a virtual machine monitor 68. The operations of this particular architecture are akin to those outlined herein in protecting an associated system from unauthorized kernel modules or binaries being run, for example, through malware.

Xend shown in FIG. 4 is a special process (e.g., a daemon) that runs as root in Domain 0. It is a part of the Xen system, where users typically interface with xend via the Xen Management (xm) commands. Xm commands to start, stop, and manage guest domains send requests to the xend daemon first, which are in turn relayed to the Xen hypervisor via a hypercall. Commonly, the xend daemon listens for requests on an open network port. The xm commands typically send requests to the listening xend daemon on the same machine. Xm is in the user interface and xend handles the validation and sequencing of requests from multiple sources. The Xen hypervisor carries out the request in most implementations. In this example, an ioctl system call is intercepted and evaluated. If the EIP address is from a writable region, the system call is failed and not performed.

Software for intercepting unauthorized binaries and kernel modules (as well as inhibiting dangerous code from being executed for already running binaries) can be provided at various locations. In one example implementation, this software is resident in a computer sought to be protected from a security attack (or protected from unwanted, or unauthorized manipulations of a privileged area). In a more detailed configuration, this software is specifically resident in Domain 0. One implementation involves providing in a security layer of a virtual machine monitor, which may include (or otherwise interface with) a kernel space and a user space, as depicted by FIG. 1.

In still other embodiments, software could be received or downloaded from a web server (e.g., in the context of purchasing individual end-user licenses for separate devices, separate virtual machines, hypervisors, servers, etc.) in order to carry out these intercepting and authorizing functions in Domain 0. In other examples, the intercepting and authorizing functions could involve a proprietary element (e.g., as part of an antivirus solution), which could be provided in (or be proximate to) these identified elements, or be provided in any other device, server, network appliance, console, firewall, switch, information technology (IT) device, etc., or be provided as a complementary solution (e.g., in conjunction with a firewall), or provisioned somewhere in the network. As used herein in this Specification, the term ‘computer’ is meant to encompass these possible elements (VMMs, hypervisors, Xen devices, virtual devices, network appliances, routers, switches, gateway, processors, servers, loadbalancers, firewalls, or any other suitable device, component, element, or object) operable to affect or process electronic information in a security environment. Moreover, this computer may include any suitable hardware, software, components, modules, interfaces, or objects that facilitate the operations thereof. This may be inclusive of appropriate algorithms and communication protocols that allow for the effective authorization of kernel modules, binaries, etc. In addition, the intercepting and authorizing functions can be consolidated in any suitable manner. Along similar design alternatives, any of the illustrated modules and components of FIGS. 1, 3, and 4 may be combined in various possible configurations: all of which are clearly within the broad scope of this Specification.

In certain example implementations, the intercepting and authorizing functions outlined herein may be implemented by logic encoded in one or more tangible media (e.g., embedded logic provided in an application specific integrated circuit (ASIC), digital signal processor (DSP) instructions, software (potentially inclusive of object code and source code) to be executed by a processor, or other similar machine, etc.). In some of these instances, a memory element (as shown in FIG. 1) can store data used for the operations described herein. This includes the memory element being able to store software, logic, code, or processor instructions that are executed to carry out the activities described in this Specification. A processor can execute any type of instructions associated with the data to achieve the operations detailed herein in this Specification. In one example, the processor (as shown in the FIGURES) could transform an element or an article (e.g., data) from one state or thing to another state or thing. In another example, the activities outlined herein may be implemented with fixed logic or programmable logic (e.g., software/computer instructions executed by a processor) and the elements identified herein could be some type of a programmable processor, programmable digital logic (e.g., a field programmable gate array (FPGA), an erasable programmable read only memory (EPROM), an electrically erasable programmable ROM (EEPROM)) or an ASIC that includes digital logic, software, code, electronic instructions, or any suitable combination thereof.

Any of these elements (e.g., a computer, a server, a network appliance, a firewall, a virtual machine element, etc.) can include memory elements for storing information to be used in achieving the intercepting and authorizing operations as outlined herein. Additionally, each of these devices may include a processor that can execute software or an algorithm to perform the intercepting and authorizing activities as discussed in this Specification. These devices may further keep information in any suitable memory element (random access memory (RAM), ROM, EPROM, EEPROM, ASIC, etc.), software, hardware, or in any other suitable component, device, element, or object where appropriate and based on particular needs. Any of the memory items discussed herein (e.g., inventory, table(s), user space, kernel space, etc.) should be construed as being encompassed within the broad term ‘memory element.’ Similarly, any of the potential processing elements, modules, and machines described in this Specification should be construed as being encompassed within the broad term ‘processor.’ Each of the computers, network appliances, virtual elements, etc. can also include suitable interfaces for receiving, transmitting, and/or otherwise communicating data or information in a secure environment.

FIG. 5 is a flowchart 100 illustrating how security agents can provide security to Domain 0 in accordance with one example embodiment. The flow begins at step 110, where a security agent is installed in Domain 0 of the virtual machine monitor. This initiates the security protection being provided for a given system. At step 120, a system snapshot is performed using the security agent. This could involve evaluating a number of entries in the system's inventory such that authorized elements (binaries, kernel modules, etc.) are identified for future reference. At step 130, the security agent is enabled and this could further involve one or more commands that initiate the protection mechanism.

Step 140 represents copying of an unauthorized binary on Domain 0. The security agent is configured to compute checksums in order to validate whether a given element (a binary or kernel module) is authorized for the particular system. These activities may include look up operations in which stored inventories are compared against new requests for binaries or kernel modules in order to discern whether to allow these elements to be executed. Thus, the comparison is being made against stored items.

At step 150, the query is answered as to whether this particular binary has been authorized. If it has not been authorized, the flow moves to step 160 where execution of the binary is denied. In such a context, an inference can be made that if the lookup reveals that the particular binary is not found, then the request is presumed to be a security risk that should not be executed. If the binary is authorized, then from step 150 the flow moves to step 170, where execution of the binary is allowed.

Note that with the examples provided herein, interaction may be described in terms of two, three, four, or more network elements. However, this has been done for purposes of clarity and example only. In certain cases, it may be easier to describe one or more of the functionalities of a given set of flows by only referencing a limited number of components or network elements. It should be appreciated that system 10 of FIG. 1 (and its teachings) is readily scalable. System 10 can accommodate a large number of components, as well as more complicated or sophisticated arrangements and configurations. Accordingly, the examples provided should not limit the scope or inhibit the broad teachings of system 10 as potentially applied to a myriad of other architectures. In addition, system 10 has been described herein as operating on particular Xen architectures; however, other systems can readily be accommodated by the present solution.

It is also important to note that the steps described with reference to the preceding FIGURES illustrate only some of the possible scenarios that may be executed by, or within, system 10. Some of these steps may be deleted or removed where appropriate, or these steps may be modified or changed considerably without departing from the scope of the discussed concepts. In addition, a number of these operations have been described as being executed concurrently with, or in parallel to, one or more additional operations. However, the timing of these operations may be altered considerably. The preceding operational flows have been offered for purposes of example and discussion. Substantial flexibility is provided by system 10 in that any suitable arrangements, chronologies, configurations, and timing mechanisms may be provided without departing from the teachings of the discussed concepts. 

What is claimed is:
 1. A method, comprising: inserting a security layer in a privileged domain of a computer configured to perform virtualization, wherein: the security layer is in a kernel of a privileged domain of a computer configured to operate in a virtual machine environment; and the privileged domain of the computer manages a virtual machine monitor (VMM) that operates at a higher priority than one or more operating systems; storing an indication of authorized objects, the authorized objects in a user space of the privileged domain; intercepting, by the security layer, a request for an execution of an object in the computer from the user space of the privileged domain; verifying the request for execution of the object by evaluating the indication of authorized objects; and allowing or denying the execution of the object based upon the verification of the request.
 2. The method of claim 1, wherein evaluating the indication of authorized objects includes evaluating authorized binaries and kernel modules.
 3. The method of claim 1, further comprising: intercepting an attempt to execute code from a previously authorized binary; and evaluating an origination address of a hypercall associated with the code before executing the code.
 4. The method of claim 1, wherein evaluating the indication of authorized objects includes comparing the object to an inventory of authorized objects stored in a user space of the computer.
 5. The method of claim 4, further comprising populating a log based on a determination that the execution of the object is not authorized.
 6. The method of claim 1, wherein: the attempted execution of the object is an attempted execution of a kernel module to perform a hypercall to access a privileged domain area within the computer; and evaluating the indication of authorized objects includes evaluating whether the hypercall to access a privileged domain area within the computer is authorized.
 7. The method of claim 1, wherein: the attempted execution of the object is an attempted modification of a virtual machine state; and evaluating the indication of authorized objects includes evaluating whether the attempted modification of the virtual machine state is authorized.
 8. A logic encoded in one or more tangible non-transitory media that includes code for execution and when executed by a processor is operable to: insert a security layer in a privileged domain of a computer, wherein: the security layer is in a kernel of a privileged domain of a computer configured to operate in a virtual machine environment; and the privileged domain is configured to manage a virtual machine monitor (VMM) that operates at a higher priority than one or more operating systems; store an indication of authorized objects in a user space of the privileged domain; intercept, by the security layer, a request for an execution of an object in the computer from the user space of the privileged domain; verify the request for execution of the object by evaluating the indication of authorized objects; and allow or deny the execution of the object based upon the verification of the request.
 9. The logic encoded in tangible non-transitory media of claim 8, wherein the processor is further operable to evaluate the indication of authorized objects by evaluating whether the object is included in authorized binaries and kernel modules.
 10. The logic encoded in tangible non-transitory media of claim 8, wherein the processor is further operable to: intercept, by the security layer, an attempt to execute code from a previously authorized binary; and evaluate an origination address of a hypercall associated with the code before executing the code.
 11. The logic encoded in tangible non-transitory media of claim 8, wherein the processor is further operable to evaluate the indication of authorized objects by comparing the object to an inventory of authorized objects stored in a user space of the computer.
 12. The logic encoded in tangible non-transitory media of claim 11, wherein the processor is further operable to populate a log based on a determination that the execution of the object is not authorized.
 13. The logic encoded in tangible non-transitory media of claim 8, wherein: the attempted execution of the object is an attempted execution of a kernel module to perform a hypercall to access a privileged domain area within the computer; and the processor is further operable to evaluate the indication of authorized objects by evaluating whether the hypercall to access a privileged domain area within the computer is authorized.
 14. The logic encoded in tangible non-transitory media of claim 8, wherein: the attempted execution of the object is an attempted modification of a virtual machine state; and the processor is further configured to evaluate the indication of authorized objects by evaluating whether the attempted modification of the virtual machine state is authorized.
 15. An apparatus, comprising: a virtual machine element comprising instructions in a memory; and a processor operable to execute the instructions in the memory to operate the virtual machine element; wherein the virtual machine element is configured to: insert a security layer in a privileged domain of the apparatus, wherein: the security layer is in a kernel of a privileged domain of a computer configured to operate in a virtual machine environment; and the privileged domain of the apparatus manages a virtual machine monitor (VMM) that operates at a higher priority than one or more operating systems; and store an indication of authorized objects in a user space of the privileged domain; wherein the security layer is configured to intercept a request for an execution of an object in the computer from the user space of the privileged domain; and wherein the virtual machine element is further configured to: verify the request for execution of the object by evaluating the indication of authorized objects; allow or deny the execution of the object based upon the verification of the request.
 16. The apparatus of claim 15, wherein: the security layer is further configured to intercept an attempt to execute code from a previously authorized binary; and the virtual machine element is further configured to evaluate an origination address of a hypercall associated with the code before executing the code.
 17. The apparatus of claim 15, wherein the virtual machine element is further configured to evaluate the indication of authorized objects by comparing the object to an inventory of authorized objects stored in a user space of the computer.
 18. The apparatus of claim 17, wherein the virtual machine element is further configured to populate a log based on a determination that the execution of the object is not authorized.
 19. The apparatus of claim 15, wherein: the attempted execution of the object is an attempted execution of a kernel module to perform a hypercall to access a privileged domain area within the computer; and wherein the virtual machine element is further configured to evaluate the indication of authorized objects by evaluating whether the hypercall to access a privileged domain area within the computer is authorized.
 20. The apparatus of claim 15, wherein: the attempted execution of the object is an attempted modification of a virtual machine state; and wherein the virtual machine element is further configured to evaluate the indication of authorized objects by evaluating whether the attempted modification of the virtual machine state is authorized. 